package com.tjetc;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class _5ArrayExercise {
    public static void main(String[] args) {
        /*
            要求： 实现动态的给数组添加元素效果，实现对数组扩容 。
            1. 原始数组使⽤静态分配 int[] arr = {1,2,3}
            2. 增加的元素4 ，直接放在数组的最后 arr = {1,2,3,4}
            3. ⽤户可以通过如下⽅法来决定是否继续添加，添加成功，是否继续？y/n

           思路分析：
           1.输入
             输入一个要增加的元素
           2.输出
             添加新元素后数组的值
           3.处理逻辑
               （1）原数组中还有位置
                    怎么原数组中还有几个位置？比如数组长度4 有3个元素 新元素插在下标3的位置
               （2）原数组中无位置
                    进行扩容 数组的长度不能增加？ 开辟一个新数组
                    将原来数组的元素复制过来 在把新元素放进去

         */
        Scanner scanner = new Scanner(System.in);
        /*
        int[] oldArr = {1, 2};
        System.out.println("请输入你要插入的元素：");
        int num = scanner.nextInt();
        // 将原数组进行扩容
        int[] newArr = new int[oldArr.length + 1];
        // 将老数据复制到新数组中
        for (int i = 0; i < oldArr.length; i++) {
            newArr[i] = oldArr[i];
        }
        newArr[newArr.length - 1] = num;
        System.out.println(Arrays.toString(newArr));

        // 数组只有一个属性 length 长度 数组有默认值
        // 我怎么知道原来数组中有几个元素？
        int size = 0;
        // 不能通过数组中默认的0来确定该位置是空元素
        */

        /*
        // 升级一下
        int[] oldArr = new int[5];
        oldArr[0] = 1;
        oldArr[1] = 2;
        // 用来表示当前数组中的元素个数
        int size = 2;
        System.out.println("请输入你要插入的元素：");
        int num = scanner.nextInt();
        // 如果满了
        if (size == oldArr.length) {
            // 进行扩容
            // 将原数组进行扩容
            int[] newArr = new int[oldArr.length + 1];
            // 将老数据复制到新数组中
            for (int i = 0; i < oldArr.length; i++) {
                newArr[i] = oldArr[i];
            }
            oldArr = newArr;
        }
        oldArr[size] = num;
        size++;
        System.out.println(Arrays.toString(oldArr));
        */

        /*
        // 升级 使用循环
        int[] oldArr = new int[5];
        oldArr[0] = 1;
        oldArr[1] = 2;
        // 用来表示当前数组中的元素个数
        int size = 2;
        System.out.println(Arrays.toString(oldArr));
        do {
            System.out.println("请输入你要插入的元素：");
            int num = scanner.nextInt();
            // 如果满了
            if (size == oldArr.length) {
                // 进行扩容
                // 将原数组进行扩容
                int[] newArr = new int[oldArr.length + 5];
                // 将老数据复制到新数组中
                for (int i = 0; i < oldArr.length; i++) {
                    newArr[i] = oldArr[i];
                }
                oldArr = newArr;
            }
            oldArr[size] = num;
            size++;
            System.out.println(Arrays.toString(oldArr));
            System.out.println("请确认是否继续添加？ y/n");
            char confirm = scanner.next().charAt(0);
            if (confirm == 'n') {
                System.out.println(Arrays.toString(oldArr));
                break;
            }
        }while (true);
        */


        // 优化
        int[] arr = new int[5];
        arr[0] = 1;
        arr[1] = 2;
        // 用来表示当前数组中的元素个数
        int size = 2;
        System.out.println(Arrays.toString(arr));
        do {
            System.out.println("请输入你要插入的元素：");
            int num = scanner.nextInt();
            // 如果满了
            if (size == arr.length) {
                // 进行扩容
                // 将原数组进行扩容
                arr = Arrays.copyOf(arr, arr.length + 5);
            }
            arr[size] = num;
            size++;
            System.out.println(Arrays.toString(arr));
            System.out.println("请确认是否继续添加？ y/n");
            char confirm = scanner.next().charAt(0);
            if (confirm == 'n') {
                System.out.println(Arrays.toString(arr));
                break;
            }
        } while (true);


    }

    public static void main2(String[] args) {
        /*
            要求：把数组的元素内容反转。
            ⽅式1：通过找规律反转
            ⽅式2：使⽤逆序赋值⽅式

            思路分析：
            1.输入
                给一个数组
            2.输出
                返回一个数组 （反转过）
            3.处理逻辑
                {1, 2, 3, 4}  ->  {4, 3, 2, 1}
                (1) {4, 2, 3, 1}
                (2) {4, 3, 2, 1}
                在原有数组中进行交换
                使用新数组
         */
        int[] arrs = {1, 2, 3, 4};
        for (int i = 0; i < arrs.length / 2; i++) {
            // 在计算机中做交换 要使用中间变量
            int temp = arrs[i];
            arrs[i] = arrs[arrs.length - 1 - i];
            arrs[arrs.length - 1 - i] = temp;
        }
        System.out.println(Arrays.toString(arrs));

        // 使用新数组 我们在做测试的时候 一定要注意排除其他的跟当前测试无关的数据
        int[] arrs1 = new int[arrs.length];
        for (int i = 0; i < arrs.length; i++) {
            arrs1[i] = arrs[arrs.length - 1 - i];
        }
        System.out.println(Arrays.toString(arrs1));

    }

    public static void main1(String[] args) {
        /*
            要求：实现数组拷⻉(内容复制)
            将 int[] arr1 = {10,20,30}; 拷⻉到 arr2 数组, 要求数据空间是独⽴的。
            思路分析：
            1.输入
                int[] arr1 = {10,20,30}
            2.输出
                一个新的数组 空间是独立
            3.处理逻辑
                (1) 新创建一个空间 这个空间大小和原来的空间一样
                （2）将旧空间中的内容 放到新空间中
         */
        int[] arr = {10, 20, 30};
//        int[] arr1 = arr;
//        System.out.println(Arrays.toString(arr1));


        // 实现
        int[] arr1 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr1[i] = arr[i];
        }

        arr1[0] = 40;
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));

    }
}
